
#ifndef Hashtable_h
#define Hashtable_h

// Riccsson includes.
#include <Typedef.h>
#include <Defines.h>
#include <CSharpPropertyMethods.h>

#include <System/Object.h>
#include <System/Collections/IDictionary.h>
#include <System/Collections/IEqualityComparer.h>
#include <System/Collections/IHashCodeProvider.h>
#include <System/Array.h>

namespace Riccsson
{
	namespace System
	{
		namespace Collections
		{
			class Hashtable
			{
						// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the default initial capacity, load factor, hash code provider, and
				//     comparer.
				public: Hashtable() { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to the new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the default load factor,
				//     hash code provider, and comparer.
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				public: Hashtable(IDictionary* d) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the default initial capacity and load factor, and the specified System.Collections.IEqualityComparer
				//     object.
				//
				// Parameters:
				//   equalityComparer:
				//     The System.Collections.IEqualityComparer object that defines the hash code
				//     provider and the comparer to use with the System.Collections.Hashtable object.-or-
				//     null to use the default hash code provider and the default comparer. The
				//     default hash code provider is each key's implementation of System.Object.GetHashCode()
				//     and the default comparer is each key's implementation of System.Object.Equals(System.Object).
				public: Hashtable(IEqualityComparer* equalityComparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity, and the default load factor, hash code
				//     provider, and comparer.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.
				public: Hashtable(int capacity) { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to the new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the specified load factor,
				//     and the default hash code provider and comparer.
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     loadFactor is less than 0.1.-or- loadFactor is greater than 1.0.
				public: Hashtable(IDictionary* d, float loadFactor) { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to a new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the default load factor
				//     and the specified System.Collections.IEqualityComparer object.
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				//   equalityComparer:
				//     The System.Collections.IEqualityComparer object that defines the hash code
				//     provider and the comparer to use with the System.Collections.Hashtable.-or-
				//     null to use the default hash code provider and the default comparer. The
				//     default hash code provider is each key's implementation of System.Object.GetHashCode()
				//     and the default comparer is each key's implementation of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				public: Hashtable(IDictionary* d, IEqualityComparer* equalityComparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the default initial capacity and load factor, and the specified hash
				//     code provider and comparer.
				//
				// Parameters:
				//   hcp:
				//     The System.Collections.IHashCodeProvider object that supplies the hash codes
				//     for all keys in the System.Collections.Hashtable object.-or- null to use
				//     the default hash code provider, which is each key's implementation of System.Object.GetHashCode().
				//
				//   comparer:
				//     The System.Collections.IComparer object to use to determine whether two keys
				//     are equal.-or- null to use the default comparer, which is each key's implementation
				//     of System.Object.Equals(System.Object).
				//[Obsolete("Please use Hashtable(IEqualityComparer) instead.")]
				public: Hashtable(IHashCodeProvider* hcp, IComparer* comparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity and load factor, and the default hash
				//     code provider and comparer.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.-or- loadFactor is less than 0.1.-or- loadFactor
				//     is greater than 1.0.
				//
				//   System.ArgumentException:
				//     capacity is causing an overflow.
				public: Hashtable(int capacity, float loadFactor) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity and System.Collections.IEqualityComparer,
				//     and the default load factor.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				//   equalityComparer:
				//     The System.Collections.IEqualityComparer object that defines the hash code
				//     provider and the comparer to use with the System.Collections.Hashtable.-or-
				//     null to use the default hash code provider and the default comparer. The
				//     default hash code provider is each key's implementation of System.Object.GetHashCode()
				//     and the default comparer is each key's implementation of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.
				public: Hashtable(int capacity, IEqualityComparer* equalityComparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     that is serializable using the specified System.Runtime.Serialization.SerializationInfo
				//     and System.Runtime.Serialization.StreamingContext objects.
				//
				// Parameters:
				//   info:
				//     A System.Runtime.Serialization.SerializationInfo object containing the information
				//     required to serialize the System.Collections.Hashtable object.
				//
				//   context:
				//     A System.Runtime.Serialization.StreamingContext object containing the source
				//     and destination of the serialized stream associated with the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     info is null.
				protected: Hashtable(SerializationInfo* info, StreamingContext* context) { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to the new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the specified load factor
				//     and System.Collections.IEqualityComparer object.
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				//   equalityComparer:
				//     The System.Collections.IEqualityComparer object that defines the hash code
				//     provider and the comparer to use with the System.Collections.Hashtable.-or-
				//     null to use the default hash code provider and the default comparer. The
				//     default hash code provider is each key's implementation of System.Object.GetHashCode()
				//     and the default comparer is each key's implementation of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     loadFactor is less than 0.1.-or- loadFactor is greater than 1.0.
				public: Hashtable(IDictionary* d, float loadFactor, IEqualityComparer* equalityComparer) { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to the new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the default load factor,
				//     and the specified hash code provider and comparer. This API is obsolete.
				//     For an alternative, see System.Collections.Hashtable.#ctor(System.Collections.IDictionary,System.Collections.IEqualityComparer).
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				//   hcp:
				//     The System.Collections.IHashCodeProvider object that supplies the hash codes
				//     for all keys in the System.Collections.Hashtable.-or- null to use the default
				//     hash code provider, which is each key's implementation of System.Object.GetHashCode().
				//
				//   comparer:
				//     The System.Collections.IComparer object to use to determine whether two keys
				//     are equal.-or- null to use the default comparer, which is each key's implementation
				//     of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				//[Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")]
				public: Hashtable(IDictionary* d, IHashCodeProvider* hcp, IComparer* comparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity, load factor, and System.Collections.IEqualityComparer
				//     object.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				//   equalityComparer:
				//     The System.Collections.IEqualityComparer object that defines the hash code
				//     provider and the comparer to use with the System.Collections.Hashtable.-or-
				//     null to use the default hash code provider and the default comparer. The
				//     default hash code provider is each key's implementation of System.Object.GetHashCode()
				//     and the default comparer is each key's implementation of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.-or- loadFactor is less than 0.1.-or- loadFactor
				//     is greater than 1.0.
				public: Hashtable(int capacity, float loadFactor, IEqualityComparer* equalityComparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity, hash code provider, comparer, and the
				//     default load factor.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				//   hcp:
				//     The System.Collections.IHashCodeProvider object that supplies the hash codes
				//     for all keys in the System.Collections.Hashtable.-or- null to use the default
				//     hash code provider, which is each key's implementation of System.Object.GetHashCode().
				//
				//   comparer:
				//     The System.Collections.IComparer object to use to determine whether two keys
				//     are equal.-or- null to use the default comparer, which is each key's implementation
				//     of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.
				//[Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")]
				public: Hashtable(int capacity, IHashCodeProvider* hcp, IComparer* comparer) { throw; }
				//
				// Summary:
				//     Initializes a new instance of the System.Collections.Hashtable class by copying
				//     the elements from the specified dictionary to the new System.Collections.Hashtable
				//     object. The new System.Collections.Hashtable object has an initial capacity
				//     equal to the number of elements copied, and uses the specified load factor,
				//     hash code provider, and comparer.
				//
				// Parameters:
				//   d:
				//     The System.Collections.IDictionary* object to copy to a new System.Collections.Hashtable
				//     object.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				//   hcp:
				//     The System.Collections.IHashCodeProvider object that supplies the hash codes
				//     for all keys in the System.Collections.Hashtable.-or- null to use the default
				//     hash code provider, which is each key's implementation of System.Object.GetHashCode().
				//
				//   comparer:
				//     The System.Collections.IComparer object to use to determine whether two keys
				//     are equal.-or- null to use the default comparer, which is each key's implementation
				//     of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     d is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     loadFactor is less than 0.1.-or- loadFactor is greater than 1.0.
				//[Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
				public: Hashtable(IDictionary* d, float loadFactor, IHashCodeProvider* hcp, IComparer* comparer) { throw; }
				//
				// Summary:
				//     Initializes a new, empty instance of the System.Collections.Hashtable class
				//     using the specified initial capacity, load factor, hash code provider, and
				//     comparer.
				//
				// Parameters:
				//   capacity:
				//     The approximate number of elements that the System.Collections.Hashtable
				//     object can initially contain.
				//
				//   loadFactor:
				//     A number in the range from 0.1 through 1.0 that is multiplied by the default
				//     value which provides the best performance. The result is the maximum ratio
				//     of elements to buckets.
				//
				//   hcp:
				//     The System.Collections.IHashCodeProvider object that supplies the hash codes
				//     for all keys in the System.Collections.Hashtable.-or- null to use the default
				//     hash code provider, which is each key's implementation of System.Object.GetHashCode().
				//
				//   comparer:
				//     The System.Collections.IComparer object to use to determine whether two keys
				//     are equal.-or- null to use the default comparer, which is each key's implementation
				//     of System.Object.Equals(System.Object).
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     capacity is less than zero.-or- loadFactor is less than 0.1.-or- loadFactor
				//     is greater than 1.0.
				//[Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")]
				public: Hashtable(int capacity, float loadFactor, IHashCodeProvider* hcp, IComparer* comparer) { throw; }

				// Summary:
				//     Gets or sets the System.Collections.IComparer to use for the System.Collections.Hashtable.
				//
				// Returns:
				//     The System.Collections.IComparer to use for the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The property is set to a value, but the hash table was created using an System.Collections.IEqualityComparer.
				//[Obsolete("Please use KeyComparer properties.")]
				protected: virtual PROP3_GET(GC_PTR<IComparer>, comparer)
				{
					throw;
				}
				protected: virtual PROP3_SET(GC_PTR<IComparer>, comparer)
				{
					throw;
				}

				//
				// Summary:
				//     Gets the number of key/value pairs contained in the System.Collections.Hashtable.
				//
				// Returns:
				//     The number of key/value pairs contained in the System.Collections.Hashtable.
				public: virtual PROP3_GET(int, Count)
				{
					throw;
				}

				//
				// Summary:
				//     Gets the System.Collections.IEqualityComparer to use for the System.Collections.Hashtable.
				//
				// Returns:
				//     The System.Collections.IEqualityComparer to use for the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The property is set to a value, but the hash table was created using an System.Collections.IHashCodeProvider
				//     and an System.Collections.IComparer.
				protected: PROP3_GET(GC_PTR<IEqualityComparer>, equalityComparer)
				{
					throw;
				}

				//
				// Summary:
				//     Gets or sets the object that can dispense hash codes.
				//
				// Returns:
				//     The object that can dispense hash codes.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The property is set to a value, but the hash table was created using an System.Collections.IEqualityComparer.
				//[Obsolete("Please use EqualityComparer property.")]
				protected: PROP3_GET(GC_PTR<IHashCodeProvider>, hcp)
				{
					throw;
				}
				protected: PROP3_SET(GC_PTR<IHashCodeProvider>, hcp)
				{
					throw;
				}

				//
				// Summary:
				//     Gets a value indicating whether the System.Collections.Hashtable has a fixed
				//     size.
				//
				// Returns:
				//     true if the System.Collections.Hashtable has a fixed size; otherwise, false.
				//     The default is false.
				public: virtual PROP3_GET(bool, IsFixedSize)
				{
					throw;
				}

				//
				// Summary:
				//     Gets a value indicating whether the System.Collections.Hashtable is read-only.
				//
				// Returns:
				//     true if the System.Collections.Hashtable is read-only; otherwise, false.
				//     The default is false.
				public: virtual PROP3_GET(bool, IsReadOnly)
				{
					throw;
				}

				//
				// Summary:
				//     Gets a value indicating whether access to the System.Collections.Hashtable
				//     is synchronized (thread safe).
				//
				// Returns:
				//     true if access to the System.Collections.Hashtable is synchronized (thread
				//     safe) { throw; } otherwise, false. The default is false.
				public: virtual PROP3_GET(bool, IsSynchronized)
				{
					throw;
				}

				//
				// Summary:
				//     Gets an System.Collections.ICollection containing the keys in the System.Collections.Hashtable.
				//
				// Returns:
				//     An System.Collections.ICollection containing the keys in the System.Collections.Hashtable.
				public: virtual PROP3_GET(GC_PTR<ICollection>, Keys)
				{
					throw;
				}

				//
				// Summary:
				//     Gets an object that can be used to synchronize access to the System.Collections.Hashtable.
				//
				// Returns:
				//     An object that can be used to synchronize access to the System.Collections.Hashtable.
				public: virtual PROP3_GET(GC_PTR<object>, SyncRoot)
				{
					throw;
				}

				//
				// Summary:
				//     Gets an System.Collections.ICollection containing the values in the System.Collections.Hashtable.
				//
				// Returns:
				//     An System.Collections.ICollection containing the values in the System.Collections.Hashtable.
				public: virtual PROP3_GET(GC_PTR<ICollection>, Values)
				{
					throw;
				}


				// Summary:
				//     Gets or sets the value associated with the specified key.
				//
				// Parameters:
				//   key:
				//     The key whose value to get or set.
				//
				// Returns:
				//     The value associated with the specified key. If the specified key is not
				//     found, attempting to get it returns null, and attempting to set it creates
				//     a new element using the specified key.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     key is null.
				//
				//   System.NotSupportedException:
				//     The property is set and the System.Collections.Hashtable is read-only.-or-
				//     The property is set, key does not exist in the collection, and the System.Collections.Hashtable
				//     has a fixed size.
				//public: virtual object this[object key] { get; set; }

				// Summary:
				//     Adds an element with the specified key and value into the System.Collections.Hashtable.
				//
				// Parameters:
				//   key:
				//     The key of the element to add.
				//
				//   value:
				//     The value of the element to add. The value can be null.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     key is null.
				//
				//   System.ArgumentException:
				//     An element with the same key already exists in the System.Collections.Hashtable.
				//
				//   System.NotSupportedException:
				//     The System.Collections.Hashtable is read-only.-or- The System.Collections.Hashtable
				//     has a fixed size.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: virtual void Add(object* key, object* value) { throw; }
				//
				// Summary:
				//     Removes all elements from the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.NotSupportedException:
				//     The System.Collections.Hashtable is read-only.
				//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
				public: virtual void Clear() { throw; }
				//
				// Summary:
				//     Creates a shallow copy of the System.Collections.Hashtable.
				//
				// Returns:
				//     A shallow copy of the System.Collections.Hashtable.
				public: virtual GC_PTR<object> Clone() { throw; }
				//
				// Summary:
				//     Determines whether the System.Collections.Hashtable contains a specific key.
				//
				// Parameters:
				//   key:
				//     The key to locate in the System.Collections.Hashtable.
				//
				// Returns:
				//     true if the System.Collections.Hashtable contains an element with the specified
				//     key; otherwise, false.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     key is null.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: virtual bool Contains(object* key) { throw; }
				//
				// Summary:
				//     Determines whether the System.Collections.Hashtable contains a specific key.
				//
				// Parameters:
				//   key:
				//     The key to locate in the System.Collections.Hashtable.
				//
				// Returns:
				//     true if the System.Collections.Hashtable contains an element with the specified
				//     key; otherwise, false.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     key is null.
				public: virtual bool ContainsKey(object* key) { throw; }
				//
				// Summary:
				//     Determines whether the System.Collections.Hashtable contains a specific value.
				//
				// Parameters:
				//   value:
				//     The value to locate in the System.Collections.Hashtable. The value can be
				//     null.
				//
				// Returns:
				//     true if the System.Collections.Hashtable contains an element with the specified
				//     value; otherwise, false.
				public: virtual bool ContainsValue(object* value) { throw; }
				//
				// Summary:
				//     Copies the System.Collections.Hashtable elements to a one-dimensional System.Array
				//     instance at the specified index.
				//
				// Parameters:
				//   array:
				//     The one-dimensional System.Array that is the destination of the System.Collections.DictionaryEntry
				//     objects copied from System.Collections.Hashtable. The System.Array must have
				//     zero-based indexing.
				//
				//   arrayIndex:
				//     The zero-based index in array at which copying begins.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     array is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     arrayIndex is less than zero.
				//
				//   System.ArgumentException:
				//     array is multidimensional.-or- The number of elements in the source System.Collections.Hashtable
				//     is greater than the available space from arrayIndex to the end of the destination
				//     array.
				//
				//   System.InvalidCastException:
				//     The type of the source System.Collections.Hashtable cannot be cast automatically
				//     to the type of the destination array.
				public: virtual void CopyTo(Array<object>* array, int arrayIndex) { throw; }
				//
				// Summary:
				//     Returns an System.Collections.IDictionaryEnumerator that iterates through
				//     the System.Collections.Hashtable.
				//
				// Returns:
				//     An System.Collections.IDictionaryEnumerator for the System.Collections.Hashtable.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: virtual IDictionaryEnumerator* GetEnumerator() { throw; }
				//
				// Summary:
				//     Returns the hash code for the specified key.
				//
				// Parameters:
				//   key:
				//     The System.Object for which a hash code is to be returned.
				//
				// Returns:
				//     The hash code for key.
				//
				// Exceptions:
				//   System.NullReferenceException:
				//     key is null.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				protected: virtual int GetHash(object* key) { throw; }
				//
				// Summary:
				//     Implements the System.Runtime.Serialization.ISerializable interface and returns
				//     the data needed to serialize the System.Collections.Hashtable.
				//
				// Parameters:
				//   info:
				//     A System.Runtime.Serialization.SerializationInfo object containing the information
				//     required to serialize the System.Collections.Hashtable.
				//
				//   context:
				//     A System.Runtime.Serialization.StreamingContext object containing the source
				//     and destination of the serialized stream associated with the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     info is null.
				//
				//   System.InvalidOperationException:
				//     The collection was modified.
				//[SecurityCritical]
				public: virtual void GetObjectData(SerializationInfo* info, StreamingContext* context) { throw; }
				//
				// Summary:
				//     Compares a specific System.Object with a specific key in the System.Collections.Hashtable.
				//
				// Parameters:
				//   item:
				//     The System.Object to compare with key.
				//
				//   key:
				//     The key in the System.Collections.Hashtable to compare with item.
				//
				// Returns:
				//     true if item and key are equal; otherwise, false.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     item is null.-or- key is null.
				protected: virtual bool KeyEquals(object* item, object* key) { throw; }
				//
				// Summary:
				//     Implements the System.Runtime.Serialization.ISerializable interface and raises
				//     the deserialization event when the deserialization is complete.
				//
				// Parameters:
				//   sender:
				//     The source of the deserialization event.
				//
				// Exceptions:
				//   System.Runtime.Serialization.SerializationException:
				//     The System.Runtime.Serialization.SerializationInfo object associated with
				//     the current System.Collections.Hashtable is invalid.
				public: virtual void OnDeserialization(object* sender) { throw; }
				//
				// Summary:
				//     Removes the element with the specified key from the System.Collections.Hashtable.
				//
				// Parameters:
				//   key:
				//     The key of the element to remove.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     key is null.
				//
				//   System.NotSupportedException:
				//     The System.Collections.Hashtable is read-only.-or- The System.Collections.Hashtable
				//     has a fixed size.
				//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
				public: virtual void Remove(object* key) { throw; }
				//
				// Summary:
				//     Returns a synchronized (thread-safe) wrapper for the System.Collections.Hashtable.
				//
				// Parameters:
				//   table:
				//     The System.Collections.Hashtable to synchronize.
				//
				// Returns:
				//     A synchronized (thread-safe) wrapper for the System.Collections.Hashtable.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     table is null.
				public: static GC_PTR<Hashtable> Synchronized(Hashtable* table) { throw; }
			};
		}
	}
}

#endif